import { asyncRoutes, constantRoutes } from '@/router'
import { useUserStore } from '@/stores/user'

/**
 * 检查路由是否有权限访问
 * @param {Object} route - 路由对象
 * @param {Array} permissions - 用户权限数组
 * @param {String} role - 用户角色
 * @returns {Boolean}
 */
function hasRoutePermission(route, permissions, role) {
  // 管理员拥有所有权限
  if (role === 'admin') {
    return true
  }
  
  // 首先检查是否有角色限制
  if (route.meta && route.meta.roles) {
    // 如果设置了角色限制，检查用户角色是否在允许的角色列表中
    if (!role || !route.meta.roles.includes(role)) {
      return false
    }
  }
  
  // 然后检查是否有权限点限制
  if (route.meta && route.meta.permissions) {
    // 如果没有权限列表，则没有权限
    if (!permissions || permissions.length === 0) {
      return false
    }
    
    // 如果路由需要权限，检查用户是否有任一所需权限
    return permissions.some(permission => route.meta.permissions.includes(permission))
  }
  
  // 如果没有设置权限要求，则默认可访问
  return true
}

/**
 * 根据权限筛选路由
 * @param {Array} routes - 路由数组
 * @param {Array} permissions - 用户权限数组
 * @param {String} role - 用户角色
 * @returns {Array} - 筛选后的路由数组
 */
export function filterRoutesByPermissions(routes, permissions, role) {
  const filteredRoutes = []

  routes.forEach(route => {
    const tmp = { ...route }
    
    // 检查当前路由是否有权限访问
    if (hasRoutePermission(tmp, permissions, role)) {
      // 如果有子路由，递归筛选
      if (tmp.children) {
        tmp.children = filterRoutesByPermissions(tmp.children, permissions, role)
      }
      filteredRoutes.push(tmp)
    }
  })

  return filteredRoutes
}

/**
 * 生成用户可访问的动态路由
 * @param {Array} permissions - 用户权限数组
 * @param {String} role - 用户角色
 * @returns {Array} - 可访问的动态路由
 */
export function generateAccessibleRoutes(permissions, role) {
  // 超级管理员可以访问所有路由
  if (role === 'admin') {
    console.log('管理员用户，获取所有路由');
    return asyncRoutes;
  }
  
  if ((!permissions || permissions.length === 0) && role !== 'admin' && !role) {
    console.log('用户无权限，返回空路由');
    return [];
  }
  
  // 手动检查是否有statistics:read权限
  const hasStatisticsPermission = permissions.includes('statistics:read');
  console.log('用户是否有统计权限:', hasStatisticsPermission);
  
  // 筛选可访问路由
  let routes = filterRoutesByPermissions(asyncRoutes, permissions, role);
  
  // 确保日志记录
  console.log('筛选后的路由数量:', routes.length);
  
  return routes;
}

/**
 * 获取用户可访问的完整路由
 * @param {Array} permissions - 用户权限数组
 * @param {String} role - 用户角色
 * @returns {Array} - 可访问的完整路由(包括静态路由)
 */
export function getAllAccessibleRoutes(permissions, role) {
  const accessibleDynamicRoutes = generateAccessibleRoutes(permissions, role)
  return [...constantRoutes, ...accessibleDynamicRoutes]
}

/**
 * 获取默认路由重定向
 * @param {Array} routes - 路由数组
 * @returns {String} - 默认路由路径
 */
export function getDefaultRoutePath(routes) {
  // 默认为首页
  let defaultPath = '/dashboard'
  
  // 查找第一个可用的非隐藏路由
  const findPath = (routes) => {
    for (const route of routes) {
      if (route.meta && !route.meta.hidden) {
        if (route.children && route.children.length > 0) {
          // 有子路由，递归查找
          const childPath = findPath(route.children)
          if (childPath) {
            return childPath
          }
        }
        // 没有子路由或未找到可用子路由，返回当前路由
        return route.path
      }
    }
    return null
  }
  
  const path = findPath(routes)
  if (path) {
    defaultPath = path
  }
  
  return defaultPath
}

/**
 * 检查当前用户是否拥有指定角色
 * @param {string|Array} roles - 单个角色或角色数组
 * @returns {boolean} - 如果用户拥有任一指定角色，返回true
 */
export const hasRole = (roles) => {
  const userStore = useUserStore()
  const userRole = userStore.userRole
  
  if (!userRole) return false
  
  // 多角色检查
  if (Array.isArray(roles)) {
    return roles.includes(userRole)
  }
  
  // 单角色检查
  return userRole === roles
}

/**
 * 检查当前用户是否拥有指定权限
 * @param {string|Array} permissions - 单个权限或权限数组
 * @returns {boolean} - 如果用户拥有任一指定权限，返回true
 */
export const checkUserPermission = (permissions) => {
  const userStore = useUserStore()
  return userStore.hasPermission(permissions)
}

/**
 * 根据角色过滤菜单项
 * @param {Array} menuItems - 菜单项数组
 * @param {Object} options - 配置选项
 * @param {string} options.roleKey - 角色属性名，默认为'roles'
 * @returns {Array} - 过滤后的菜单项
 */
export const filterMenuByRole = (menuItems, options = {}) => {
  const { roleKey = 'roles' } = options
  const userStore = useUserStore()
  const userRole = userStore.userRole
  
  if (!userRole || !menuItems || !Array.isArray(menuItems)) {
    return []
  }
  
  return menuItems.filter(item => {
    // 如果没有指定角色，则对所有用户可见
    if (!item[roleKey] || item[roleKey].length === 0) {
      return true
    }
    
    // 检查用户角色是否在允许的角色列表中
    return item[roleKey].includes(userRole)
  })
}

/**
 * Vue指令：v-role
 * 用法：v-role="'admin'" 或 v-role="['admin', 'doctor']"
 */
export const roleDirective = {
  mounted(el, binding) {
    const { value } = binding
    const hasUserRole = hasRole(value)
    
    if (!hasUserRole) {
      // 如果用户没有所需角色，移除元素
      el.parentNode && el.parentNode.removeChild(el)
    }
  }
}

/**
 * Vue指令：v-permission
 * 用法：v-permission="'user:create'" 或 v-permission="['user:create', 'user:edit']"
 */
export const permissionDirective = {
  mounted(el, binding) {
    const { value } = binding
    const hasUserPermission = checkUserPermission(value)
    
    if (!hasUserPermission) {
      // 如果用户没有所需权限，移除元素
      el.parentNode && el.parentNode.removeChild(el)
    }
  }
}

// 注册全局指令
export const setupPermissionDirectives = (app) => {
  app.directive('role', roleDirective)
  app.directive('permission', permissionDirective)
}

export default {
  hasRoutePermission,
  filterRoutesByPermissions,
  generateAccessibleRoutes,
  getAllAccessibleRoutes,
  getDefaultRoutePath,
  hasRole,
  filterMenuByRole,
  roleDirective,
  permissionDirective,
  setupPermissionDirectives
} 